home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 7: Sunsite / Linux Cubed Series 7 - Sunsite Vol 1.iso / system / filesyst / dosfs / dmsdosfs.000 / dmsdosfs / dmsdosfs-0.6.9b / dmsdos_spc.c < prev    next >
C/C++ Source or Header  |  1996-07-29  |  31KB  |  1,069 lines
  1. /*
  2. linux/fs/dmsdos/dmsdos_spc.c
  3.  
  4. DMSDOS filesystem: special routines.
  5.  
  6. ******************************************************************************
  7. DMSDOS (Doublespace/Drivespace compressed MSDOS filesystem) for Linux
  8. written 1995,1996 by Frank Gockel
  9.  
  10.     (C) Copyright 1995,1996 by Frank Gockel
  11.  
  12. Some code of the dmsdos filesystem has been copied from the msdos filesystem
  13. so there are the following additional copyrights:
  14.  
  15.     (C) Copyright 1992,1993 by Werner Almesberger (msdos filesystem)
  16.     (C) Copyright 1994,1995 by Jacques Gelinas (mmap code)
  17.     (C) Copyright 1992-1995 by Linus Torvalds
  18.  
  19. The DMSDOS filesystem was inspired by the THS filesystem (a simple doublespace
  20. DS-0-2 compressed read-only filesystem) written 1994 by Thomas Scheuermann.
  21.  
  22. The DMSDOS filesystem is distributed under the Gnu General Public Licence.
  23. See file COPYING for details.
  24. ******************************************************************************
  25.  
  26. */
  27.  
  28. #include <linux/sched.h>
  29. #include <linux/ctype.h>
  30. #include <linux/major.h>
  31. #include <linux/blkdev.h>
  32. #include <linux/fs.h>
  33. #include <linux/stat.h>
  34. #include <linux/locks.h>
  35. #include <asm/segment.h>
  36. #include <linux/mm.h>
  37. #include <linux/malloc.h>
  38. #include <linux/string.h>
  39. #include <linux/msdos_fs.h>
  40. #include <linux/dmsdos_fs.h>
  41. #include <linux/errno.h>
  42. #include <linux/kernel.h>
  43. #include <linux/shm.h>
  44. #include <linux/mman.h>
  45. #include <asm/system.h>
  46.  
  47. /* hmmm... seems to have moved in newer kernels... */
  48. #ifdef __FOR_KERNEL_1_3_8x
  49. #include "../fat/msbuffer.h"
  50. #else
  51. #include "../msdos/msbuffer.h"
  52. #endif
  53.  
  54. #define PRINTK(X)
  55. #define CLPOS 26
  56.  
  57. /* change the 'define' to 'undef' if you want to inhibit write access */
  58. #define DBL_WRITEACCESS
  59.  
  60. /* change this if your FAT bit size is not recognized correctly -- you
  61.    should also report this to the author */
  62. #undef BELIEVE_SUPERBLOCK
  63.  
  64. int dbl_cvf_inos[MAXDBLFILES];
  65. int dbl_cvf_startcluster[MAXDBLFILES];
  66.  
  67. Dblsb dblsb[MAXDBLFILES];
  68.  
  69. Acache mdfat[MDFATCACHESIZE];
  70. Acache dfat[DFATCACHESIZE];
  71. Acache bitfat[BITFATCACHESIZE];
  72.  
  73. int dbl_sb_dev[MAXDBLFILES];
  74.  
  75. int lowest_never_used_cvfnr=0;
  76.  
  77. struct buffer_head* read_real_sector(struct super_block* sb,int sector)
  78. { struct buffer_head*bh;
  79.   /*printk("DMSDOS: read_real_sector %d\n",sector);*/
  80. #ifdef __FOR_KERNEL_1_3_8x
  81.   bh=fat_bread(sb,sector);
  82. #else
  83.   bh=msdos_bread(sb,sector);
  84. #endif
  85.   if(bh==NULL)printk("DMSDOS: read_real_sector %d failed\n",sector);
  86.   return bh;
  87. }
  88.  
  89. struct buffer_head* noread_real_sector(struct super_block* sb,int sector)
  90. { struct buffer_head*bh;
  91.   /*printk("DMSDOS: noread_real_sector %d\n",sector);*/
  92. #ifdef __FOR_KERNEL_1_3_8x
  93.   bh=fat_getblk(sb,sector);
  94.   if(bh==NULL)printk("DMSDOS: noread_real_sector %d failed\n",sector);
  95.   else fat_set_uptodate(sb,bh,1);
  96. #else
  97.   bh=msdos_getblk(sb,sector);
  98.   if(bh==NULL)printk("DMSDOS: noread_real_sector %d failed\n",sector);
  99.   else msdos_set_uptodate(sb,bh,1);
  100. #endif
  101.   return bh;
  102. }
  103.  
  104. void bh_free(struct super_block* sb,struct buffer_head*bh)
  105. { 
  106. #ifdef __FOR_KERNEL_1_3_8x
  107.   fat_brelse(sb,bh);
  108. #else
  109.   msdos_brelse(sb,bh);
  110. #endif
  111. }
  112.  
  113. void bh_dirty(struct super_block*sb,struct buffer_head*bh)
  114. { 
  115. #ifdef DBL_WRITEACCESS
  116. #ifdef __FOR_KERNEL_1_3_8x
  117.   fat_mark_buffer_dirty(sb,bh,1);
  118. #else
  119.   msdos_mark_buffer_dirty(sb,bh,1); /* !!! */
  120. #endif
  121. #else
  122.   printk("DMSDOS: illegal write access, ignored\n");
  123. #endif
  124. }
  125.  
  126. int calc_real_sector(int dblsector, int cvfnr)
  127. { int i;
  128.   int sz;
  129.   
  130.   /* calculate physical sector */
  131.   i=0;sz=dblsector;
  132.   do
  133.   { sz-=dblsb[cvfnr].s_anzahl[i];
  134.     ++i;
  135.   }
  136.   while(sz>=0&&i<MAXFRAGMENT);
  137.   --i;
  138.   sz+=dblsb[cvfnr].s_anzahl[i]+dblsb[cvfnr].s_first[i];
  139.   return sz;
  140. }
  141.  
  142. int dos_cluster2sector(struct super_block * sb,int clusternr)
  143. { return (clusternr-2)*MSDOS_SB(sb)->cluster_size+MSDOS_SB(sb)->data_start;
  144. }
  145.  
  146. struct buffer_head* read_dbl_sector(struct super_block*sb,int dblsector,
  147.                                     int cvfnr)
  148. { int sector;
  149.  
  150. /*printk("DMSDOS: read_dbl_sector: sector=%d of CVF %d\n",dblsector,cvfnr+1);*/
  151.   sector=calc_real_sector(dblsector,cvfnr);
  152.   return read_real_sector(sb,sector);
  153. }
  154.  
  155. struct buffer_head* noread_dbl_sector(struct super_block*sb,int dblsector,
  156.                                       int cvfnr)
  157. { int sector;
  158.  
  159. /*printk("DMSDOS: noread_dbl_sector: sector=%d of CVF %d\n",dblsector,cvfnr+1);
  160. */
  161.   sector=calc_real_sector(dblsector,cvfnr);
  162.   return noread_real_sector(sb,sector);
  163. }
  164.  
  165. int setup_fragment(struct super_block*sb, int cvfnr)
  166. { int fragmentzaehler;
  167.   int clusterzaehler;
  168.   int akt_cluster;
  169.   int folge_cluster;
  170.   int i;
  171.   
  172.   /*printk("DMSDOS: setup_fragment CVF %d\n",cvfnr+1);*/
  173.   fragmentzaehler=0;
  174.  
  175.   folge_cluster=dbl_cvf_startcluster[cvfnr];
  176.   
  177.   do
  178.   {
  179.     clusterzaehler=0;
  180.     dblsb[cvfnr].s_first[fragmentzaehler]=folge_cluster;
  181.     do
  182.     { akt_cluster=folge_cluster;
  183.       folge_cluster=fat_access(sb,akt_cluster,-1);
  184.       ++clusterzaehler;
  185.     }
  186.     while(folge_cluster==akt_cluster+1);
  187.   
  188.     dblsb[cvfnr].s_anzahl[fragmentzaehler]=clusterzaehler;
  189.     /*printk("DMSDOS: firstclust=%d anz=%d\n",
  190.            dblsb[cvfnr].s_first[fragmentzaehler],
  191.            dblsb[cvfnr].s_anzahl[fragmentzaehler]);
  192.     */
  193.            
  194.     ++fragmentzaehler;  
  195.   }
  196.   while(folge_cluster>0&&fragmentzaehler<MAXFRAGMENT);
  197.   if(fragmentzaehler==MAXFRAGMENT&&folge_cluster>0)
  198.   { /* zu fragmentiert, raus */
  199.     dbl_cvf_inos[cvfnr]=0;
  200.     dbl_sb_dev[cvfnr]=0;
  201.     printk("DMSDOS: CVF %d too fragmented, not mounted. See doc.\n",cvfnr+1);
  202.     return -1; 
  203.   }
  204.   /*printk("DMSDOS: CVF %d has %d fragment(s)\n",cvfnr+1,fragmentzaehler);*/
  205.   
  206.   /* convert cluster-oriented numbers into sector-oriented ones */
  207.   for(i=0;i<fragmentzaehler;++i)
  208.   { /*printk("DMSDOS: umrechnen 1\n");*/
  209.     dblsb[cvfnr].s_first[i]=dos_cluster2sector(sb,dblsb[cvfnr].s_first[i]);
  210.     /*printk("DMSDOS: umrechnen 2\n");*/
  211.     dblsb[cvfnr].s_anzahl[i]*=MSDOS_SB(sb)->cluster_size;
  212.     /*printk("DMSDOS: umrechnen 3\n");*/                                          
  213.   }
  214.   return 0;
  215. }
  216.  
  217. void setup_mdfat(struct super_block*sb,int cvfnr,int nofix)
  218. { 
  219.   struct buffer_head*bh;
  220.   struct buffer_head*bh2;
  221.   int i,mdfatb,fatb;
  222.   unsigned char * pp;
  223.  
  224.    /*printk("DMSDOS: setup_mdfat with CVF %d\n",cvfnr+1);*/
  225.     for(i=0;i<MAXFRAGMENT;++i)
  226.     { dblsb[cvfnr].s_first[i]=0;
  227.       dblsb[cvfnr].s_anzahl[i]=0;
  228.     }
  229.     if(setup_fragment(sb,cvfnr)<0)return; 
  230.     
  231.     /*printk("DMSDOS: reading %d. CVF boot block...\n",cvfnr+1);*/
  232.     bh=read_dbl_sector(sb,0,cvfnr);
  233.     if(bh==NULL)
  234.     { printk("DMSDOS: unable to read super block of CVF %d\n",cvfnr+1);
  235.       dbl_cvf_inos[cvfnr]=0;
  236.       dbl_sb_dev[cvfnr]=0;
  237.       return;
  238.     }
  239.     /*printk("DMSDOS: boot block read finished\n");*/
  240.     pp=&(bh->b_data[3]);
  241.     if(strncmp(pp,"MSDBL6.0",8)!=0&&strncmp(pp,"MSDSP6.0",8)!=0)
  242.     { printk("DMSDOS: MSDBL/MSDSP signature not found, CVF %d skipped\n",cvfnr+1);
  243.       dbl_cvf_inos[cvfnr]=0;
  244.       dbl_sb_dev[cvfnr]=0;
  245.       bh_free(sb,bh);
  246.       return;
  247.     }
  248.     pp=&(bh->b_data[45]);
  249.     dblsb[cvfnr].s_dcluster=CHS(pp);
  250.     if(dblsb[cvfnr].s_dcluster&0x8000)dblsb[cvfnr].s_dcluster|=0xffff0000;
  251.     pp=&(bh->b_data[36]);
  252.     dblsb[cvfnr].s_mdfatstart=CHS(pp)+1;
  253.     pp=&(bh->b_data[17]);
  254.     dblsb[cvfnr].s_rootdiranzentry=CHS(pp);
  255.     dblsb[cvfnr].s_sectperclust=((unsigned long)(bh->b_data[13]));
  256.     pp=&(bh->b_data[39]);i=CHS(pp);/*i=res0*/
  257.     dblsb[cvfnr].s_bootblock=i;
  258.     pp=&(bh->b_data[14]);
  259.     dblsb[cvfnr].s_fatstart=i+CHS(pp);
  260.     pp=&(bh->b_data[41]);
  261.     dblsb[cvfnr].s_rootdir=i+CHS(pp);
  262.     pp=&(bh->b_data[43]);
  263.     dblsb[cvfnr].s_datastart=i+CHS(pp)+2;
  264.     pp=&(bh->b_data[57]);
  265.     
  266. #ifdef BELIEVE_SUPERBLOCK
  267.     if(CHL(pp)==0x20203631)dblsb[cvfnr].s_16bitfat=1;
  268.     else if(CHL(pp)==0x20203231)dblsb[cvfnr].s_16bitfat=0;
  269.     else
  270.     { /* analyse emulated boot block (new format compatibility [arghhh...] ) */
  271.       printk("DMSDOS: CVF %d seems to be in new format, analysing emulated boot block\n",
  272.              cvfnr+1);
  273.       /* win95 has long filenames */
  274.       if((dblsb[cvfnr].s_support_lfn&3)==2)dblsb[cvfnr].s_support_lfn|=1;
  275. #endif
  276.       bh2=read_dbl_sector(sb,dblsb[cvfnr].s_bootblock,cvfnr);
  277.       if(bh2==NULL)
  278.       { printk("DMSDOS: unable to read emulated boot block of CVF %d\n",cvfnr+1);
  279.         dbl_cvf_inos[cvfnr]=0;
  280.         dbl_sb_dev[cvfnr]=0;
  281.         bh_free(sb,bh);
  282.         return;
  283.       }
  284.       pp=&(bh2->b_data[57]);
  285.       if(CHL(pp)==0x20203631)dblsb[cvfnr].s_16bitfat=1;
  286.       else if(CHL(pp)==0x20203231)dblsb[cvfnr].s_16bitfat=0;
  287.       else
  288.       {
  289.         pp=&(bh->b_data[62]);
  290.         dblsb[cvfnr].s_16bitfat=(CHS(pp)>32) ? 1 : 0;
  291.         printk("DMSDOS: FAT bit size of CVF %d not recognized, guessed %d bit\n",
  292.                cvfnr+1,CHS(pp)>32 ? 16 : 12 );
  293.       }
  294.       bh_free(sb,bh2); 
  295. #ifdef BELIEVE_SUPERBLOCK
  296.     }
  297. #endif
  298.     
  299.     dblsb[cvfnr].s_full=0;
  300.     
  301.     /* calculate maximum cluster nr (fixes lost cluster messages) */
  302.     mdfatb=(dblsb[cvfnr].s_bootblock-dblsb[cvfnr].s_mdfatstart);
  303.     mdfatb*=((dblsb[cvfnr].s_sectperclust>16)?102:128);
  304.     mdfatb-=dblsb[cvfnr].s_dcluster;
  305.     fatb=512*(dblsb[cvfnr].s_rootdir-dblsb[cvfnr].s_fatstart);
  306.     if(dblsb[cvfnr].s_16bitfat)fatb/=2; else fatb=(2*fatb)/3;
  307.     dblsb[cvfnr].s_max_cluster=((mdfatb<fatb)?mdfatb:fatb)-1;
  308.     if(dblsb[cvfnr].s_16bitfat)
  309.     { if(dblsb[cvfnr].s_max_cluster>0xFFF6)dblsb[cvfnr].s_max_cluster=0xFFF6;
  310.     }
  311.     else
  312.     { if(dblsb[cvfnr].s_max_cluster>0xFF6)dblsb[cvfnr].s_max_cluster=0xFF6;
  313.     }
  314.  
  315.     /* adapt max_cluster according to dos' limits */
  316.     dblsb[cvfnr].s_max_cluster2=dblsb[cvfnr].s_max_cluster;
  317.     pp=&(bh->b_data[32]);
  318.     i=CHL(pp);
  319.     pp=&(bh->b_data[22]);
  320.     i-=CHS(pp);
  321.     pp=&(bh->b_data[14]);
  322.     i-=CHS(pp);
  323.     i-=dblsb[cvfnr].s_rootdiranzentry>>4;
  324.     i=(i>>4)+1;
  325.     if(i<=dblsb[cvfnr].s_max_cluster)
  326.     { dblsb[cvfnr].s_max_cluster=i;
  327.     }
  328.     else
  329.     { printk("DMSDOS: CVF %d: dos max_cluster=%d too large, cutting to %d.\n",
  330.              cvfnr+1,i,dblsb[cvfnr].s_max_cluster);
  331.     }
  332.     
  333.     bh_free(sb,bh);
  334.         
  335.  /*
  336.     printk("DMSDOS: dcluster=%d\n",dblsb[cvfnr].s_dcluster);
  337.     printk("DMSDOS: mdfatstart=%d\n",dblsb[cvfnr].s_mdfatstart);
  338.     printk("DMSDOS: rootdiranzentry=%d\n",dblsb[cvfnr].s_rootdiranzentry);
  339.     printk("DMSDOS: sectperclust=%d\n",dblsb[cvfnr].s_sectperclust);
  340.     printk("DMSDOS: fatstart=%d\n",dblsb[cvfnr].s_fatstart);
  341.     printk("DMSDOS: rootdir=%d\n",dblsb[cvfnr].s_rootdir);
  342.     printk("DMSDOS: %d bit FAT\n",dblsb[cvfnr].s_16bitfat ? 16 : 12);
  343.  */  
  344.     /* error test */
  345.     i=simple_check(sb,cvfnr);
  346.     if(i==-1||i==-2)
  347.     { printk("DMSDOS: CVF %d has serious errors, setting to read-only.\n",
  348.              cvfnr+1);
  349.       dblsb[cvfnr].s_comp=READ_ONLY;
  350.     }
  351.     if(i==-3)
  352.     { printk("DMSDOS: CVF %d has minor errors, errors ignored.\n",cvfnr+1);
  353.     }
  354.     
  355.     if(dblsb[cvfnr].s_sectperclust>16)
  356.     { 
  357.       printk("DMSDOS: CVF %d is in drivespace 3 format.\n",cvfnr+1);
  358.       if(dblsb[cvfnr].s_comp!=READ_ONLY&&nofix==0)fixdir(sb,cvfnr);
  359.     }
  360. }
  361.  
  362. struct wait_queue * mdfatwait=NULL;
  363. int mdfatlock=0;
  364. void lock_mdfat(void)
  365. { while(mdfatlock)sleep_on(&mdfatwait);
  366.   mdfatlock=1;
  367. }
  368. void unlock_mdfat(void)
  369. { mdfatlock=0;
  370.   wake_up(&mdfatwait);
  371. }
  372.  
  373. struct wait_queue * dfatwait=NULL;
  374. int dfatlock=0;
  375. void lock_dfat(void)
  376. { while(dfatlock)sleep_on(&dfatwait);
  377.   dfatlock=1;
  378. }
  379. void unlock_dfat(void)
  380. { dfatlock=0;
  381.   wake_up(&dfatwait);
  382. }
  383.  
  384. struct wait_queue * bitfatwait=NULL;
  385. int bitfatlock=0;
  386. void lock_bitfat(void)
  387. { while(bitfatlock)sleep_on(&bitfatwait);
  388.   bitfatlock=1;
  389. }
  390. void unlock_bitfat(void)
  391. { bitfatlock=0;
  392.   wake_up(&bitfatwait);
  393. }
  394.  
  395. void read_mdfat_sector(struct super_block*sb,int area,int merk_i,int cvfnr)
  396. {
  397. /*printk("DMSDOS: reading dbl_mdfat sector %d of CVF %d\n",area,cvfnr+1);*/
  398.   
  399.   if(mdfat[merk_i].a_buffer!=NULL)bh_free(sb,mdfat[merk_i].a_buffer);
  400.   if((mdfat[merk_i].a_buffer=read_dbl_sector(sb,area,cvfnr))==NULL)
  401.   { panic("DMSDOS: unable to read mdfat\n");
  402.   }
  403.   mdfat[merk_i].a_area=area;
  404.   mdfat[merk_i].a_time=CURRENT_TIME;
  405.   mdfat[merk_i].a_acc=0;
  406.   mdfat[merk_i].a_cvfnr=cvfnr;
  407. }
  408.  
  409. void read_dfat_sector(struct super_block*sb,int area,int merk_i,int cvfnr)
  410. {
  411.   /*printk("DMSDOS: reading dbl_fat sector %d of CVF %d\n",area,cvfnr+1);*/
  412.   
  413.   if(dfat[merk_i].a_buffer!=NULL)bh_free(sb,dfat[merk_i].a_buffer);
  414.   if((dfat[merk_i].a_buffer=read_dbl_sector(sb,area,cvfnr))==NULL)
  415.   { panic("DMSDOS: unable to read dfat\n");
  416.   }
  417.   dfat[merk_i].a_area=area;
  418.   dfat[merk_i].a_time=CURRENT_TIME;
  419.   dfat[merk_i].a_acc=0;
  420.   dfat[merk_i].a_cvfnr=cvfnr;
  421.   
  422.   /*printk("cluster 2 fat entry=%d\n",mdfat[cvfnr].fat_data[merk_i][2]);*/ 
  423. }
  424.  
  425. void read_bitfat_sector(struct super_block*sb,int area,int merk_i,int cvfnr)
  426. {
  427.   /*printk("DMSDOS: reading bitfat sector %d of CVF %d\n",area,cvfnr+1);*/
  428.   
  429.   if(bitfat[merk_i].a_buffer!=NULL)bh_free(sb,bitfat[merk_i].a_buffer);
  430.   if((bitfat[merk_i].a_buffer=read_dbl_sector(sb,area,cvfnr))==NULL)
  431.   { panic("DMSDOS: unable to read bitfat\n");
  432.   }
  433.   bitfat[merk_i].a_area=area;
  434.   bitfat[merk_i].a_time=CURRENT_TIME;
  435.   bitfat[merk_i].a_acc=0;
  436.   bitfat[merk_i].a_cvfnr=cvfnr;
  437. }
  438.  
  439. void u_dumpcache(Acache*c)
  440. { printk("area=%d time=%ld acc=%d cvfnr=%d buffer=%p\n",c->a_area,c->a_time,
  441.          c->a_acc,c->a_cvfnr+1,c->a_buffer);
  442. }
  443.  
  444. void dumpcache(void)
  445. { int i;
  446.   
  447.   printk("DMSDOS: mdfat cache:\n");
  448.   for(i=0;i<MDFATCACHESIZE;++i)u_dumpcache(&(mdfat[i]));
  449.   printk("DMSDOS: dfat cache:\n");
  450.   for(i=0;i<DFATCACHESIZE;++i)u_dumpcache(&(dfat[i]));
  451.   printk("DMSDOS: bitfat cache:\n");
  452.   for(i=0;i<BITFATCACHESIZE;++i)u_dumpcache(&(bitfat[i]));
  453. }
  454.  
  455. void dbl_mdfat_value(struct super_block*sb,int clusternr,int cvfnr,
  456.                      Mdfat_entry*new,
  457.                      Mdfat_entry*mde)
  458. { int i;
  459.   int area;
  460.   int pos;
  461.   int offset;
  462.   unsigned long min_time;
  463.   unsigned int min_acc;
  464.   int merk_i,merk_i2,merk_i3;
  465.   unsigned char * pp;
  466.   int res;
  467.   unsigned char mdfat_raw_field[5];
  468.  
  469.   if(dblsb[cvfnr].s_sectperclust>16)
  470.     /* the following formula is _guessed_ and may be awfully wrong 
  471.     pos=(dblsb[cvfnr].s_dcluster+clusternr)*5+512*dblsb[cvfnr].s_mdfatstart;
  472.     ... it *is* wrong... */
  473.     /* or this one... with sector alignment - changes in max_cluster
  474.        necessary!!!! */
  475.     pos=(dblsb[cvfnr].s_dcluster+clusternr)*5
  476.         +((dblsb[cvfnr].s_dcluster+clusternr)/102)*2
  477.         +512*dblsb[cvfnr].s_mdfatstart;
  478.   else  
  479.     pos=(dblsb[cvfnr].s_dcluster+clusternr)*4+512*dblsb[cvfnr].s_mdfatstart;
  480.   area=pos/SECTOR_SIZE;
  481.   offset=(pos%SECTOR_SIZE);                           
  482.   
  483.   lock_mdfat();
  484.   
  485.   merk_i2=-1; /* never free this cached sector */
  486.   
  487. mdfat_redo:
  488.   
  489.   min_time=mdfat[0].a_time;
  490.   min_acc=mdfat[0].a_acc;
  491.   merk_i=0;
  492.   if(merk_i2==0)
  493.   { min_time=mdfat[1].a_time;
  494.     min_acc=mdfat[1].a_acc;
  495.     merk_i=1;
  496.   }
  497.   /* find area and cvfnr in cache */
  498.   for(i=0;i<MDFATCACHESIZE;++i)
  499.   { if( ( mdfat[i].a_time<min_time||
  500.             (mdfat[i].a_time==min_time&&mdfat[i].a_acc<min_acc)
  501.         ) &&merk_i2!=i)    
  502.     { min_time=mdfat[i].a_time;
  503.       min_acc=mdfat[i].a_acc;
  504.       merk_i=i;
  505.     }
  506.     if(mdfat[i].a_buffer!=NULL&&area==mdfat[i].a_area&&cvfnr==mdfat[i].a_cvfnr)
  507.     { /* found */
  508.       if(mdfat[i].a_time==CURRENT_TIME)++mdfat[i].a_acc;
  509.       else
  510.       { mdfat[i].a_time=CURRENT_TIME;
  511.         mdfat[i].a_acc=0;
  512.       }
  513.       merk_i=i;
  514.       goto mdfat_okay;      /************* goto ************************/
  515.     }
  516.   }
  517.   /* merk_i = least recently used entry number */
  518.   read_mdfat_sector(sb,area,merk_i,cvfnr);
  519.  
  520. mdfat_okay:
  521. /*
  522.   pp=&(mdfat[merk_i].a_buffer->b_data[offset]);
  523.   res=CHL(pp);
  524.   if(new)
  525.   { pp[0]=*new;pp[1]=*new>>8;pp[2]=*new>>16;pp[3]=*new>>24;
  526.     bh_dirty(sb,mdfat[merk_i].a_buffer);
  527.     /printk("DMSDOS: mdfat write cluster=%d value=0x%08x\n",clusternr,*new);/
  528.   }
  529.   unlock_mdfat();
  530.   return res;
  531. */
  532.  
  533.   if(dblsb[cvfnr].s_sectperclust<=16)
  534.   { /* normal... */
  535.     pp=&(mdfat[merk_i].a_buffer->b_data[offset]);
  536.     res=CHL(pp);
  537.     mde->sector_minus_1=res&0x1fffff;
  538.     mde->unknown=(res&0x00200000)>>21;
  539.     mde->size_lo_minus_1=(res&0x03c00000)>>22;
  540.     mde->size_hi_minus_1=(res&0x3c000000)>>26;
  541.     mde->flags=((res&0xC0000000)>>30)&3;
  542.     if(new)
  543.     { res=new->sector_minus_1;res&=0x1fffff;
  544.       /* unknown bit ??? don't know... set to zero */
  545.       res|=new->size_lo_minus_1<<22;res&=0x03ffffff;
  546.       res|=new->size_hi_minus_1<<26;res&=0x3fffffff;
  547.       res|=new->flags<<30;
  548.       pp[0]=res;pp[1]=res>>8;pp[2]=res>>16;pp[3]=res>>24;
  549.       bh_dirty(sb,mdfat[merk_i].a_buffer);
  550.     }
  551.     unlock_mdfat();
  552.     return;
  553.   }
  554.  
  555.   /* drivspace 3 mdfat access  _experimental_ but seems to work */
  556.  
  557.   /* read 2. sector if necessary */
  558.   if(offset+4>511&&merk_i2==-1)
  559.   { merk_i2=merk_i;
  560.     ++area;
  561.     goto mdfat_redo;
  562.   }
  563.   if(offset+4>511)
  564.   { merk_i3=merk_i;
  565.     merk_i=merk_i2;
  566.     merk_i2=merk_i3;
  567.   }
  568.   else merk_i2=merk_i;
  569.   
  570.   /* copy data in mdfat_raw_field (5 byte) */
  571.   for(i=0;i<5;++i)
  572.   { if(i+offset<512)
  573.       mdfat_raw_field[i]=mdfat[merk_i].a_buffer->b_data[i+offset];
  574.     else
  575.       mdfat_raw_field[i]=mdfat[merk_i2].a_buffer->b_data[i+offset-512];
  576.   }
  577.   
  578.   /* setup mde */
  579.   mde->sector_minus_1=CHL(mdfat_raw_field)&0xffffff;
  580.   mde->unknown=(CHL(mdfat_raw_field)&0x3000000)>>24;
  581.   mde->size_lo_minus_1=(mdfat_raw_field[3]>>2)&0x3f;
  582.   mde->size_hi_minus_1=mdfat_raw_field[4]&0x3f;
  583.   mde->flags=(mdfat_raw_field[4]>>6)&3;
  584.   
  585.   /* if new!=NULL, setup 5 byte from new in mdfat_raw_field */
  586.   if(new)
  587.   { mdfat_raw_field[0]=new->sector_minus_1&0xffffff;
  588.     /* unknown bits set to zero */
  589.     mdfat_raw_field[1]=new->sector_minus_1>>8;
  590.     mdfat_raw_field[2]=new->sector_minus_1>>16;
  591.     mdfat_raw_field[3]=(new->sector_minus_1>>24)&3;
  592.     mdfat_raw_field[3]|=new->size_lo_minus_1<<2;
  593.     mdfat_raw_field[4]=new->size_hi_minus_1&0x3f;
  594.     mdfat_raw_field[4]|=new->flags<<6;
  595.     
  596.     /* write back mdfat_raw_entry */
  597.     for(i=0;i<5;++i)
  598.     { if(i+offset<512)
  599.         mdfat[merk_i].a_buffer->b_data[i+offset]=mdfat_raw_field[i];
  600.       else
  601.         mdfat[merk_i2].a_buffer->b_data[i+offset-512]=mdfat_raw_field[i];
  602.     }
  603.     
  604.     /* mark buffer dirty (both if necessary) */
  605.     bh_dirty(sb,mdfat[merk_i].a_buffer);
  606.     if(merk_i!=merk_i2)bh_dirty(sb,mdfat[merk_i2].a_buffer);
  607.     
  608.   }
  609.   
  610.   unlock_mdfat();
  611.   return;
  612. }
  613.  
  614. int dbl_mdfat_cluster2sector(struct super_block*sb,int clusternr,int cvfnr)
  615. { Mdfat_entry mde;
  616.   dbl_mdfat_value(sb,clusternr,cvfnr,NULL,&mde);
  617.   return mde.sector_minus_1+1;
  618. }
  619.  
  620. int dbl_fat_nextcluster(struct super_block*sb,int clusternr,int cvfnr,int*new)
  621. { int i;
  622.   int area;
  623.   int pos;
  624.   int offset;
  625.   unsigned long min_time;
  626.   unsigned int min_acc;
  627.   int merk_i;
  628.   int res;
  629.   int newval;
  630.   int merk_i2;
  631.   int merk_i3;
  632.   int offset2;
  633.   
  634.   merk_i2=-1; /* never free this cached sector */
  635.   pos= dblsb[cvfnr].s_fatstart*512;
  636.   pos+= dblsb[cvfnr].s_16bitfat ? clusternr*2 : clusternr*3/2;
  637.        
  638.   area=pos/SECTOR_SIZE;
  639.   offset=pos%SECTOR_SIZE;                           
  640.   
  641.   lock_dfat();
  642.   
  643. dfat_retry:
  644.   
  645.   min_time=dfat[0].a_time;
  646.   min_acc=dfat[0].a_acc;
  647.   merk_i=0;
  648.   if(merk_i2==0)
  649.   { min_time=dfat[1].a_time;
  650.     min_acc=dfat[1].a_acc;
  651.     merk_i=1;
  652.   }
  653.   /* find area and cvfnr in cache */
  654.   for(i=0;i<DFATCACHESIZE;++i)
  655.   { if( ( dfat[i].a_time<min_time ||
  656.            (dfat[i].a_time==min_time&&dfat[i].a_acc<min_acc) 
  657.         ) &&merk_i2!=i)
  658.     { min_time=dfat[i].a_time;
  659.       min_acc=dfat[i].a_acc;
  660.       merk_i=i;
  661.     }
  662.     if(dfat[i].a_buffer!=NULL&&area==dfat[i].a_area&&cvfnr==dfat[i].a_cvfnr)
  663.     { /* found */
  664.       if(dfat[i].a_time==CURRENT_TIME)++dfat[i].a_acc;
  665.       else
  666.       { dfat[i].a_time=CURRENT_TIME;
  667.         dfat[i].a_acc=0;
  668.       }
  669.       merk_i=i;
  670.       goto dfat_okay;
  671.     }
  672.   }
  673.   /* merk_i = least recently used entry */
  674.   read_dfat_sector(sb,area,merk_i,cvfnr);
  675.   
  676. dfat_okay:
  677.   if(offset==511&&merk_i2==-1)
  678.   { /* ⁿbertrag, mist, folgesektor auch noch lesen, alten nicht rauswerfen */
  679.     merk_i2=merk_i;
  680.     ++area;
  681.     goto dfat_retry;
  682.   }
  683.   if(offset==511)
  684.   { /* gerade zweiten sektor gelesen */
  685.     merk_i3=merk_i;
  686.     merk_i=merk_i2; /* wiederherstellen */
  687.     merk_i2=merk_i3; /* folgesektor */
  688.     offset2=0;
  689.   }
  690.   else
  691.   { /* normal */
  692.     merk_i2=merk_i;
  693.     offset2=offset+1;
  694.   }
  695.  
  696. /*  
  697. printk("DMSDOS FAT lookup: area=%d merk_i=%d merk_i2=%d offset=%d offset2=%d\n",
  698.        area,merk_i,merk_i2,offset,offset2);
  699. printk("DMSDOS FAT lookup: low=%d high=%d\n",
  700.        dfat[merk_i].a_buffer->b_data[offset],
  701.        dfat[merk_i2].a_buffer->b_data[offset2]); 
  702. */
  703.  
  704.   res=dfat[merk_i].a_buffer->b_data[offset];
  705.   res&=0xff; /* grmpf... sign problems !!!! this is brutal but it works */
  706.   res|=dfat[merk_i2].a_buffer->b_data[offset2]<<8;
  707.   res&=0xffff;
  708.   
  709.   if(new)
  710.   { if(dblsb[cvfnr].s_16bitfat) newval=*new&0xFFFF;
  711.     else
  712.     { if(clusternr&1) newval=(res&0xF) | ((*new&0xFFF)<<4);
  713.       else newval=(res&0xF000) | (*new&0xFFF);
  714.     }
  715.     dfat[merk_i].a_buffer->b_data[offset]=newval;
  716.     dfat[merk_i2].a_buffer->b_data[offset2]=newval>>8;
  717.     bh_dirty(sb,dfat[merk_i].a_buffer);
  718.     if(merk_i!=merk_i2)bh_dirty(sb,dfat[merk_i2].a_buffer);
  719.   }
  720.   unlock_dfat();
  721.   if(dblsb[cvfnr].s_16bitfat)return res>=0xFFF7 ? -1 : res;
  722.   if(clusternr&1)res>>=4; else res&=0xfff;
  723.   return res>=0xff7 ? -1 : res;
  724. }
  725.  
  726. int dbl_bitfat_value(struct super_block*sb,int sektornr,int cvfnr,int*new)
  727. { int i;
  728.   int area;
  729.   int pos;
  730.   int offset;
  731.   unsigned long min_time;
  732.   unsigned int min_acc;
  733.   int merk_i;
  734.   unsigned char * pp;
  735.   int bitmask;
  736.   int res;
  737.   int newval;
  738.   
  739.   if(sektornr<dblsb[cvfnr].s_datastart)return -1;
  740.   if(sektornr>dblsb[cvfnr].s_dataend)return -1;
  741.   pos=SECTOR_SIZE+((sektornr-dblsb[cvfnr].s_datastart)>>4)*2;
  742.   area=pos/SECTOR_SIZE;
  743.   offset=(pos%SECTOR_SIZE);
  744.   bitmask=0x8000>>((sektornr-dblsb[cvfnr].s_datastart)&15);                           
  745.   
  746.   lock_bitfat();
  747.   
  748.   min_time=bitfat[0].a_time;
  749.   min_acc=bitfat[0].a_acc;
  750.   merk_i=0;
  751.   /* find area and cvfnr in cache */
  752.   for(i=0;i<BITFATCACHESIZE;++i)
  753.   { if(bitfat[i].a_time<min_time ||
  754.         (bitfat[i].a_time==min_time&&bitfat[i].a_acc<min_acc) )
  755.     { min_time=bitfat[i].a_time;
  756.       min_acc=bitfat[i].a_acc;
  757.       merk_i=i;
  758.     }
  759.     if(bitfat[i].a_buffer!=NULL&&area==bitfat[i].a_area&&
  760.        cvfnr==bitfat[i].a_cvfnr)
  761.     { /* found */
  762.       if(bitfat[i].a_time==CURRENT_TIME)++bitfat[i].a_acc;
  763.       else
  764.       { bitfat[i].a_time=CURRENT_TIME;
  765.         bitfat[i].a_acc=0;
  766.       }
  767.       merk_i=i;
  768.       goto bitfat_okay;      /************* goto ************************/
  769.     }
  770.   }
  771.   /* merk_i = least recently used entry number */
  772.   read_bitfat_sector(sb,area,merk_i,cvfnr);
  773.  
  774. bitfat_okay:
  775.   pp=&(bitfat[merk_i].a_buffer->b_data[offset]);
  776.   res=CHS(pp);
  777.   if(new)
  778.   { newval= (*new) ? (res|bitmask) : (res&~bitmask);
  779.     pp[0]=newval;pp[1]=newval>>8;
  780.     bh_dirty(sb,bitfat[merk_i].a_buffer);
  781.   }
  782.   unlock_bitfat();
  783.   return (res&bitmask) ? 1 : 0;
  784. }
  785.  
  786.  
  787. int dbltest(struct inode* inode)
  788. { int i;
  789.  
  790.   if(lowest_never_used_cvfnr==0)return 0; /* dmsdos was never in action, 
  791.                                              values are undefined
  792.                                              (this is only for umsdos since
  793.                                              umsdos may call this without
  794.                                              dbl_init being called before) */
  795.  
  796.   /* am I the inode of a CVF? */
  797.   if(inode->i_ino==0)return 0; /* there is no zero ino for dmsdos */
  798.   for(i=0;i<MAXDBLFILES;++i) 
  799.   { if(dbl_cvf_inos[i]==inode->i_ino&&dbl_sb_dev[i]==inode->i_sb->s_dev)
  800.        return (i+1)<<DMSDOS_CVFNR_BITS;
  801.   }
  802.   return 0;
  803. }
  804.                                            
  805. int dostest(struct inode* inode)
  806. { /* am I a real DOS inode (=1) or an inode of or in a CVF (=0) */
  807.   if(inode->i_ino<=DMSDOS_ORIGINO_MASK&&dbltest(inode)==0)return 1;
  808.   return 0;
  809. }
  810.  
  811. int find_free_cvfnr(void)
  812. { int i;
  813.  
  814.   for(i=0;i<MAXDBLFILES;++i)
  815.   { if(dbl_cvf_inos[i]==0)return i;
  816.   }
  817.   return -1;
  818. }
  819.  
  820. int dbl_init(struct super_block* sb, void* datai, int comp,int cf,int ilong,
  821.               int vfat,int low,int nofix)
  822. { int i,j;
  823.   int cvfnr;
  824.   struct buffer_head * bh;
  825.   struct msdos_dir_entry * data;
  826.   char dname[]="        .   ";
  827.   
  828.   printk("DMSDOS filesystem version %d.%d.%d%s"
  829. #ifndef DBL_WRITEACCESS
  830.          " read-only"
  831. #else    
  832.          " read-write"
  833. #endif
  834. #ifdef SERIALIZE_RW_ACCESS
  835.          " serialized"
  836. #endif
  837.          "\n",
  838.          (DMSDOS_VERSION&0xff0000)>>16,
  839.          (DMSDOS_VERSION&0x00ff00)>>8,DMSDOS_VERSION&0xff,DMSDOS_LT);
  840.  
  841.   if(lowest_never_used_cvfnr==0)
  842.   { /* first call of DMSDOS filesystem, initialising variables */
  843.   
  844.     /* clear rwlist */
  845.     clear_list();
  846.   
  847.     for(i=0;i<MAXDBLFILES;++i)
  848.     {  dbl_cvf_inos[i]=0;
  849.        dbl_sb_dev[i]=0;
  850.     }
  851.     for(i=0;i<MDFATCACHESIZE;++i)
  852.     {  mdfat[i].a_time=0;
  853.        mdfat[i].a_acc=0;
  854.        mdfat[i].a_buffer=NULL;
  855.     }
  856.     for(i=0;i<DFATCACHESIZE;++i)
  857.     {  dfat[i].a_time=0;
  858.        dfat[i].a_acc=0;
  859.        dfat[i].a_buffer=NULL;
  860.     }
  861.     for(i=0;i<BITFATCACHESIZE;++i)
  862.     {  bitfat[i].a_time=0;
  863.        bitfat[i].a_acc=0;
  864.        bitfat[i].a_buffer=NULL;
  865.     }
  866.     lowest_never_used_cvfnr=MAXDBLFILES;
  867.   }
  868.   
  869.   /* check for maximum cluster size to avoid fs corruption */
  870.   if(MSDOS_SB(sb)->cluster_size>DMSDOS_MAX_DOS_SECTPERCLUST)
  871.   {  printk("DMSDOS: msdos cluster size too large, can't continue\n");
  872.      return -1;
  873.   }
  874.     
  875.   for(i=0;i<MSDOS_SB(sb)->dir_entries/MSDOS_DPS;++i)
  876.   { bh=read_real_sector(sb,MSDOS_SB(sb)->dir_start+i);
  877.     if(bh==NULL)
  878.     {  printk("DMSDOS: unable to read msdos root directory\n");
  879.        return -1;
  880.     }
  881.     data=(struct msdos_dir_entry*) bh->b_data;
  882.     
  883.     for(j=0;j<MSDOS_DPS;++j)
  884.     { if(strncmp(data[j].name,"DRVSPACE",8)==0 
  885.           || strncmp(data[j].name,"DBLSPACE",8)==0 )
  886.       { if(data[j].name[8]>='0'&&data[j].name[8]<='9'
  887.            &&data[j].name[9]>='0'&&data[j].name[9]<='9'
  888.            &&data[j].name[10]>='0'&&data[j].name[10]<='9'
  889.           ){ /* it is a CVF */
  890.              if((cvfnr=find_free_cvfnr())>=0)
  891.              { dbl_cvf_startcluster[cvfnr]=data[j].start;
  892.                dblsb[cvfnr].s_dataend=data[j].size/SECTOR_SIZE-2;
  893.                                                     /*         ^^^ the last
  894.                                                        sector seems to be
  895.                                                        reserved for some
  896.                                                        purpose...
  897.                                                     */
  898. #ifndef DBL_WRITEACCESS
  899.                comp=READ_ONLY;
  900. #endif
  901.                dblsb[cvfnr].s_comp=comp;
  902.                dblsb[cvfnr].s_cfaktor=cf;
  903.                dblsb[cvfnr].s_support_lfn=ilong+4*vfat;
  904.                dbl_cvf_inos[cvfnr]=(MSDOS_SB(sb)->dir_start+i)*MSDOS_DPS+j;
  905.                dbl_sb_dev[cvfnr]=sb->s_dev;
  906.                strncpy(dname,data[j].name,8);
  907.                strncpy(&(dname[9]),&(data[j].name[8]),3);
  908.                printk("DMSDOS: mounting CVF %s as CVF %d on device %x ino=%d %s...\n",
  909.                       dname,cvfnr+1,dbl_sb_dev[cvfnr],dbl_cvf_inos[cvfnr],
  910.                       comp==READ_ONLY?"read-only":"read-write");
  911.                setup_mdfat(sb,cvfnr,nofix);
  912.                if(((dblsb[cvfnr].s_support_lfn&1)==0)||low!=0)
  913.                    dblsb[cvfnr].s_support_lfn|=8; /*uppercase->lowercase on*/
  914.              }
  915.              else printk("DMSDOS: too many CVFs, ignoring\n");
  916.            } 
  917.       }
  918.     }
  919.     bh_free(sb,bh);
  920.   }
  921. /*printk("DMSDOS: msdos_read_super reports data_start=%d cluster_size=%d\n",
  922.          MSDOS_SB(sb)->data_start,MSDOS_SB(sb)->cluster_size);*/
  923.   
  924.   return 0;
  925. }
  926.  
  927. void exit_dbl(struct super_block*sb)
  928. { int cvfnr,j;
  929.  
  930.   if(lowest_never_used_cvfnr==0)return;
  931.   
  932.   for(cvfnr=0;cvfnr<MAXDBLFILES;++cvfnr)
  933.   { if(dbl_sb_dev[cvfnr]==sb->s_dev)
  934.     { /*printk("DMSDOS: CVF %d ino=%d on device %d unmounted.\n",
  935.              cvfnr+1,dbl_cvf_inos[cvfnr],sb->s_dev);*/
  936.       
  937.       /* kill rwlist entries */
  938.       clear_list_cvfnr(cvfnr);
  939.       
  940.       /* zero out special infos about unmounted cvf */
  941.       dbl_sb_dev[cvfnr]=0;
  942.       dbl_cvf_inos[cvfnr]=0;
  943.       
  944.       /* kill buffers used by unmounted cvf */
  945.       for(j=0;j<MDFATCACHESIZE;++j)
  946.       { if(mdfat[j].a_cvfnr==cvfnr)
  947.         { if(mdfat[j].a_buffer!=NULL)
  948.           { bh_free(sb,mdfat[j].a_buffer); 
  949.             mdfat[j].a_buffer=NULL;
  950.           }
  951.           mdfat[j].a_time=0;
  952.           mdfat[j].a_acc=0;
  953.         }
  954.       }
  955.       for(j=0;j<DFATCACHESIZE;++j)
  956.       { if(dfat[j].a_cvfnr==cvfnr)
  957.         { if(dfat[j].a_buffer!=NULL)
  958.           { bh_free(sb,dfat[j].a_buffer);
  959.             dfat[j].a_buffer=NULL;
  960.           }
  961.           dfat[j].a_time=0;
  962.           dfat[j].a_acc=0;
  963.         }
  964.       }
  965.       for(j=0;j<BITFATCACHESIZE;++j)
  966.       { if(bitfat[j].a_cvfnr==cvfnr)
  967.         { if(bitfat[j].a_buffer!=NULL)
  968.           { bh_free(sb,bitfat[j].a_buffer);
  969.             bitfat[j].a_buffer=NULL;
  970.           }
  971.           bitfat[j].a_time=0;
  972.           bitfat[j].a_acc=0;
  973.         }
  974.       }
  975.       
  976.     }
  977.   }
  978. }
  979.  
  980. /* simple fs check routines (DON'T mount obviously damaged filesystems rw)
  981. */
  982. int simple_check(struct super_block*sb,int cvfnr)
  983. { /* unsigned char field[512*1024]; grr... panics (stack overflow) */
  984.   unsigned char *field;
  985.   unsigned char bits[8]={1,2,4,8,16,32,64,128};
  986.   int i,j,val;
  987.   Mdfat_entry mde;
  988.  
  989. #define setbit(nr) field[nr/8]|=bits[nr%8]
  990. #define getbit(nr) (field[nr/8]&bits[nr%8])
  991.  
  992.   /* check fat */
  993.   
  994.   /* get memory for field */
  995.   val=dblsb[cvfnr].s_max_cluster2/8 + 1;
  996.   field=(unsigned char*)MALLOC(val);
  997.   if(field==NULL)
  998.   { printk("DMSDOS: simple_check aborted (no memory)\n");
  999.     return 1;
  1000.   }
  1001.   for(i=0;i<val;++i)field[i]=0;
  1002.   
  1003.   for(i=2;i<=dblsb[cvfnr].s_max_cluster2;++i)
  1004.   { val=dbl_fat_nextcluster(sb,i,cvfnr,NULL);
  1005.     if(val!=0&&val!=-1)
  1006.     {
  1007.       if(getbit(val))
  1008.       { printk("DMSDOS: FAT crosslink in CVF %d detected (cluster %d)\n",
  1009.                cvfnr+1,i);
  1010.         FREE(field);
  1011.         return -1;
  1012.       }
  1013.       setbit(val);
  1014.     }
  1015.   }
  1016.   
  1017.   FREE(field);
  1018.   
  1019.   /* check mdfat */
  1020.   
  1021.   val=dblsb[cvfnr].s_dataend/8 + 1;
  1022.   field=(unsigned char*)MALLOC(val);
  1023.   if(field==NULL)
  1024.   { printk("DMSDOS: simple_check: MDFAT+BITFAT test skipped (no memory)\n");
  1025.     return 2;
  1026.   }
  1027.   for(i=0;i<val;++i)field[i]=0;
  1028.   
  1029.   for(i=2;i<=dblsb[cvfnr].s_max_cluster2;++i)
  1030.   { dbl_mdfat_value(sb,i,cvfnr,NULL,&mde);
  1031.     if(mde.flags&2)
  1032.     {
  1033.       val=mde.sector_minus_1;
  1034.       if(val+mde.size_lo_minus_1>=dblsb[cvfnr].s_dataend||
  1035.          val+1<dblsb[cvfnr].s_datastart)
  1036.       { printk("DMSDOS: MDFAT entry invalid in CVF %d (cluster %d)\n",
  1037.                cvfnr+1,i);
  1038.         FREE(field);
  1039.         return -2;
  1040.       }
  1041.       for(j=0;j<=mde.size_lo_minus_1;++j)
  1042.       { ++val;
  1043.         if(getbit(val))
  1044.         { printk("DMSDOS: MDFAT crosslink in CVF %d detected\n",cvfnr+1);
  1045.           FREE(field);
  1046.           return -2;
  1047.         }
  1048.         setbit(val);
  1049.       }
  1050.     }
  1051.   }
  1052.   
  1053.   /* check bitfat */
  1054.  
  1055.   /* dataend-1 problem corrected above - dmsdos doesn't touch the
  1056.      last sector now because it seems to be reserved... */
  1057.  
  1058.   for(i=dblsb[cvfnr].s_datastart;i<=dblsb[cvfnr].s_dataend;++i)
  1059.   { if(dbl_bitfat_value(sb,i,cvfnr,NULL)!=(getbit(i)?1:0))
  1060.     { printk("DMSDOS: BITFAT mismatches MDFAT in CVF %d (sector %d)\n",
  1061.              cvfnr+1,i);
  1062.       FREE(field);
  1063.       return -3;
  1064.     }
  1065.   }
  1066.   
  1067.   FREE(field);
  1068.   return 0;      
  1069. }